// $ANTLR 3.1.1 ANML.g 2010-06-01 19:37:48

package gov.nasa.anml.parsing;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;

public class ANMLLexer extends Lexer {
    public static final int IndefinitePoint=30;
    public static final int LessThan=66;
    public static final int Ket=32;
    public static final int Implies=105;
    public static final int OrBit=112;
    public static final int AndLog=108;
    public static final int TDuration=40;
    public static final int Stmts=10;
    public static final int LETTER=133;
    public static final int Before=33;
    public static final int Fluents=6;
    public static final int Constants=5;
    public static final int Bind=16;
    public static final int After=35;
    public static final int DefinitePoint=28;
    public static final int XorLog=106;
    public static final int LabelRef=14;
    public static final int Lend=96;
    public static final int Actions=7;
    public static final int EOF=-1;
    public static final int LessThanE=129;
    public static final int AndBit=115;
    public static final int Variable=75;
    public static final int NotLog=80;
    public static final int ForAll=91;
    public static final int When=52;
    public static final int TEnd=39;
    public static final int NotBit=81;
    public static final int Access=17;
    public static final int Undefined=71;
    public static final int Use=97;
    public static final int ContainsAllExpr=47;
    public static final int ExistsExpr=50;
    public static final int Decompositions=12;
    public static final int ForAllStmt=49;
    public static final int This=57;
    public static final int ContainsSomeExpr=46;
    public static final int TimedStmt=42;
    public static final int DefiniteInterval=27;
    public static final int Colon=104;
    public static final int INT=121;
    public static final int Action=25;
    public static final int NotEqual=127;
    public static final int TimedExpr=43;
    public static final int Equal=83;
    public static final int Fluent=20;
    public static final int With=68;
    public static final int Block=11;
    public static final int Object=63;
    public static final int Float=60;
    public static final int LeftC=78;
    public static final int Range=55;
    public static final int Minus=111;
    public static final int WS=134;
    public static final int Semi=69;
    public static final int LeftB=85;
    public static final int Function=76;
    public static final int Times=113;
    public static final int OrLog=107;
    public static final int MLC=136;
    public static final int TypeRefine=18;
    public static final int ExistsStmt=51;
    public static final int TBra=36;
    public static final int IndefiniteInterval=29;
    public static final int Else=90;
    public static final int Label=26;
    public static final int ForAllExpr=48;
    public static final int Types=4;
    public static final int End=120;
    public static final int Parameters=8;
    public static final int Fact=77;
    public static final int Unordered=116;
    public static final int Undefine=72;
    public static final int Within=98;
    public static final int LeftP=73;
    public static final int ESC=132;
    public static final int All=102;
    public static final int TStart=38;
    public static final int SLC=135;
    public static final int Decomposition=88;
    public static final int False=125;
    public static final int GreaterThanE=130;
    public static final int Constant=22;
    public static final int FLOAT=122;
    public static final int Enum=54;
    public static final int ID=56;
    public static final int GreaterThan=128;
    public static final int Consume=95;
    public static final int Arguments=9;
    public static final int Assign=67;
    public static final int Change=93;
    public static final int Chain=41;
    public static final int TypeRef=13;
    public static final int Produce=94;
    public static final int WhenElse=53;
    public static final int Ordered=117;
    public static final int ConstantFunction=23;
    public static final int Bra=31;
    public static final int Exists=92;
    public static final int String=62;
    public static final int Symbol=61;
    public static final int DIGIT=131;
    public static final int Predicate=65;
    public static final int ContainsSomeStmt=44;
    public static final int True=124;
    public static final int Vector=64;
    public static final int RightP=74;
    public static final int Start=119;
    public static final int Type=19;
    public static final int At=34;
    public static final int Delta=101;
    public static final int XorBit=109;
    public static final int Contains=89;
    public static final int TKet=37;
    public static final int ContainsAllStmt=45;
    public static final int RightC=79;
    public static final int RightB=87;
    public static final int SetAssign=99;
    public static final int Duration=86;
    public static final int Divide=114;
    public static final int Parameter=24;
    public static final int Goal=84;
    public static final int Ref=15;
    public static final int Skip=100;
    public static final int Plus=110;
    public static final int Boolean=58;
    public static final int Dot=118;
    public static final int EqualLog=82;
    public static final int Dots=103;
    public static final int Infinity=126;
    public static final int Comma=70;
    public static final int Integer=59;
    public static final int STRING=123;
    public static final int FluentFunction=21;

    	public Token emit() {
    		Token t = new ANMLToken(input, state.type, state.channel, state.tokenStartCharIndex, getCharIndex()-1);
    		t.setLine(state.tokenStartLine);
    		t.setText(state.text);
    		t.setCharPositionInLine(state.tokenStartCharPositionInLine);
    		emit(t);
    		return t;
    	}


    // delegates
    // delegators

    public ANMLLexer() {;} 
    public ANMLLexer(CharStream input) {
        this(input, new RecognizerSharedState());
    }
    public ANMLLexer(CharStream input, RecognizerSharedState state) {
        super(input,state);

    }
    public String getGrammarFileName() { return "ANML.g"; }

    // $ANTLR start "NotLog"
    public final void mNotLog() throws RecognitionException {
        try {
            int _type = NotLog;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:880:7: ( 'not' | 'Not' | 'NOT' )
            int alt1=3;
            int LA1_0 = input.LA(1);

            if ( (LA1_0=='n') ) {
                alt1=1;
            }
            else if ( (LA1_0=='N') ) {
                int LA1_2 = input.LA(2);

                if ( (LA1_2=='o') ) {
                    alt1=2;
                }
                else if ( (LA1_2=='O') ) {
                    alt1=3;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 1, 2, input);

                    throw nvae;
                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 1, 0, input);

                throw nvae;
            }
            switch (alt1) {
                case 1 :
                    // ANML.g:880:9: 'not'
                    {
                    match("not"); 


                    }
                    break;
                case 2 :
                    // ANML.g:881:4: 'Not'
                    {
                    match("Not"); 


                    }
                    break;
                case 3 :
                    // ANML.g:881:12: 'NOT'
                    {
                    match("NOT"); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NotLog"

    // $ANTLR start "AndLog"
    public final void mAndLog() throws RecognitionException {
        try {
            int _type = AndLog;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:883:8: ( 'and' | 'And' | 'AND' )
            int alt2=3;
            int LA2_0 = input.LA(1);

            if ( (LA2_0=='a') ) {
                alt2=1;
            }
            else if ( (LA2_0=='A') ) {
                int LA2_2 = input.LA(2);

                if ( (LA2_2=='n') ) {
                    alt2=2;
                }
                else if ( (LA2_2=='N') ) {
                    alt2=3;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 2, 2, input);

                    throw nvae;
                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 2, 0, input);

                throw nvae;
            }
            switch (alt2) {
                case 1 :
                    // ANML.g:883:10: 'and'
                    {
                    match("and"); 


                    }
                    break;
                case 2 :
                    // ANML.g:884:4: 'And'
                    {
                    match("And"); 


                    }
                    break;
                case 3 :
                    // ANML.g:884:12: 'AND'
                    {
                    match("AND"); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "AndLog"

    // $ANTLR start "OrLog"
    public final void mOrLog() throws RecognitionException {
        try {
            int _type = OrLog;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:886:7: ( 'or' | 'Or' | 'OR' )
            int alt3=3;
            int LA3_0 = input.LA(1);

            if ( (LA3_0=='o') ) {
                alt3=1;
            }
            else if ( (LA3_0=='O') ) {
                int LA3_2 = input.LA(2);

                if ( (LA3_2=='r') ) {
                    alt3=2;
                }
                else if ( (LA3_2=='R') ) {
                    alt3=3;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 3, 2, input);

                    throw nvae;
                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 3, 0, input);

                throw nvae;
            }
            switch (alt3) {
                case 1 :
                    // ANML.g:886:9: 'or'
                    {
                    match("or"); 


                    }
                    break;
                case 2 :
                    // ANML.g:887:4: 'Or'
                    {
                    match("Or"); 


                    }
                    break;
                case 3 :
                    // ANML.g:887:11: 'OR'
                    {
                    match("OR"); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "OrLog"

    // $ANTLR start "XorLog"
    public final void mXorLog() throws RecognitionException {
        try {
            int _type = XorLog;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:889:8: ( 'xor' | 'Xor' | 'XOR' )
            int alt4=3;
            int LA4_0 = input.LA(1);

            if ( (LA4_0=='x') ) {
                alt4=1;
            }
            else if ( (LA4_0=='X') ) {
                int LA4_2 = input.LA(2);

                if ( (LA4_2=='o') ) {
                    alt4=2;
                }
                else if ( (LA4_2=='O') ) {
                    alt4=3;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 4, 2, input);

                    throw nvae;
                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 4, 0, input);

                throw nvae;
            }
            switch (alt4) {
                case 1 :
                    // ANML.g:889:10: 'xor'
                    {
                    match("xor"); 


                    }
                    break;
                case 2 :
                    // ANML.g:890:4: 'Xor'
                    {
                    match("Xor"); 


                    }
                    break;
                case 3 :
                    // ANML.g:890:12: 'XOR'
                    {
                    match("XOR"); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "XorLog"

    // $ANTLR start "EqualLog"
    public final void mEqualLog() throws RecognitionException {
        try {
            int _type = EqualLog;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:892:9: ( 'equals' | 'iff' | 'Equals' | 'EQUALS' )
            int alt5=4;
            switch ( input.LA(1) ) {
            case 'e':
                {
                alt5=1;
                }
                break;
            case 'i':
                {
                alt5=2;
                }
                break;
            case 'E':
                {
                int LA5_3 = input.LA(2);

                if ( (LA5_3=='q') ) {
                    alt5=3;
                }
                else if ( (LA5_3=='Q') ) {
                    alt5=4;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 5, 3, input);

                    throw nvae;
                }
                }
                break;
            default:
                NoViableAltException nvae =
                    new NoViableAltException("", 5, 0, input);

                throw nvae;
            }

            switch (alt5) {
                case 1 :
                    // ANML.g:892:11: 'equals'
                    {
                    match("equals"); 


                    }
                    break;
                case 2 :
                    // ANML.g:893:4: 'iff'
                    {
                    match("iff"); 


                    }
                    break;
                case 3 :
                    // ANML.g:893:12: 'Equals'
                    {
                    match("Equals"); 


                    }
                    break;
                case 4 :
                    // ANML.g:893:23: 'EQUALS'
                    {
                    match("EQUALS"); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "EqualLog"

    // $ANTLR start "Implies"
    public final void mImplies() throws RecognitionException {
        try {
            int _type = Implies;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:895:8: ( 'implies' | 'Implies' | 'IMPLIES' )
            int alt6=3;
            int LA6_0 = input.LA(1);

            if ( (LA6_0=='i') ) {
                alt6=1;
            }
            else if ( (LA6_0=='I') ) {
                int LA6_2 = input.LA(2);

                if ( (LA6_2=='m') ) {
                    alt6=2;
                }
                else if ( (LA6_2=='M') ) {
                    alt6=3;
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 6, 2, input);

                    throw nvae;
                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 6, 0, input);

                throw nvae;
            }
            switch (alt6) {
                case 1 :
                    // ANML.g:895:10: 'implies'
                    {
                    match("implies"); 


                    }
                    break;
                case 2 :
                    // ANML.g:896:4: 'Implies'
                    {
                    match("Implies"); 


                    }
                    break;
                case 3 :
                    // ANML.g:896:16: 'IMPLIES'
                    {
                    match("IMPLIES"); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Implies"

    // $ANTLR start "NotBit"
    public final void mNotBit() throws RecognitionException {
        try {
            int _type = NotBit;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:899:7: ( '!' | '~' )
            // ANML.g:
            {
            if ( input.LA(1)=='!'||input.LA(1)=='~' ) {
                input.consume();

            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NotBit"

    // $ANTLR start "AndBit"
    public final void mAndBit() throws RecognitionException {
        try {
            int _type = AndBit;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:900:7: ( '&' )
            // ANML.g:900:9: '&'
            {
            match('&'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "AndBit"

    // $ANTLR start "OrBit"
    public final void mOrBit() throws RecognitionException {
        try {
            int _type = OrBit;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:901:6: ( '|' )
            // ANML.g:901:8: '|'
            {
            match('|'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "OrBit"

    // $ANTLR start "XorBit"
    public final void mXorBit() throws RecognitionException {
        try {
            int _type = XorBit;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:902:8: ( '~&|' )
            // ANML.g:902:10: '~&|'
            {
            match("~&|"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "XorBit"

    // $ANTLR start "Times"
    public final void mTimes() throws RecognitionException {
        try {
            int _type = Times;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:908:6: ( '*' )
            // ANML.g:908:8: '*'
            {
            match('*'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Times"

    // $ANTLR start "Divide"
    public final void mDivide() throws RecognitionException {
        try {
            int _type = Divide;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:909:7: ( '/' )
            // ANML.g:909:9: '/'
            {
            match('/'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Divide"

    // $ANTLR start "Plus"
    public final void mPlus() throws RecognitionException {
        try {
            int _type = Plus;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:910:5: ( '+' )
            // ANML.g:910:7: '+'
            {
            match('+'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Plus"

    // $ANTLR start "Minus"
    public final void mMinus() throws RecognitionException {
        try {
            int _type = Minus;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:911:6: ( '-' )
            // ANML.g:911:8: '-'
            {
            match('-'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Minus"

    // $ANTLR start "Equal"
    public final void mEqual() throws RecognitionException {
        try {
            int _type = Equal;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:913:7: ( '==' )
            // ANML.g:913:9: '=='
            {
            match("=="); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Equal"

    // $ANTLR start "NotEqual"
    public final void mNotEqual() throws RecognitionException {
        try {
            int _type = NotEqual;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:914:10: ( '!=' | '~=' )
            int alt7=2;
            int LA7_0 = input.LA(1);

            if ( (LA7_0=='!') ) {
                alt7=1;
            }
            else if ( (LA7_0=='~') ) {
                alt7=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 7, 0, input);

                throw nvae;
            }
            switch (alt7) {
                case 1 :
                    // ANML.g:914:12: '!='
                    {
                    match("!="); 


                    }
                    break;
                case 2 :
                    // ANML.g:914:19: '~='
                    {
                    match("~="); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "NotEqual"

    // $ANTLR start "LessThan"
    public final void mLessThan() throws RecognitionException {
        try {
            int _type = LessThan;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:915:10: ( '<' )
            // ANML.g:915:12: '<'
            {
            match('<'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LessThan"

    // $ANTLR start "LessThanE"
    public final void mLessThanE() throws RecognitionException {
        try {
            int _type = LessThanE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:916:11: ( '<=' )
            // ANML.g:916:13: '<='
            {
            match("<="); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LessThanE"

    // $ANTLR start "GreaterThan"
    public final void mGreaterThan() throws RecognitionException {
        try {
            int _type = GreaterThan;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:917:12: ( '>' )
            // ANML.g:917:14: '>'
            {
            match('>'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "GreaterThan"

    // $ANTLR start "GreaterThanE"
    public final void mGreaterThanE() throws RecognitionException {
        try {
            int _type = GreaterThanE;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:918:13: ( '>=' )
            // ANML.g:918:15: '>='
            {
            match(">="); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "GreaterThanE"

    // $ANTLR start "SetAssign"
    public final void mSetAssign() throws RecognitionException {
        try {
            int _type = SetAssign;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:920:10: ( ':in' )
            // ANML.g:920:12: ':in'
            {
            match(":in"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "SetAssign"

    // $ANTLR start "Assign"
    public final void mAssign() throws RecognitionException {
        try {
            int _type = Assign;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:922:8: ( ':=' )
            // ANML.g:922:10: ':='
            {
            match(":="); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Assign"

    // $ANTLR start "Consume"
    public final void mConsume() throws RecognitionException {
        try {
            int _type = Consume;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:924:8: ( ':consume' )
            // ANML.g:924:10: ':consume'
            {
            match(":consume"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Consume"

    // $ANTLR start "Produce"
    public final void mProduce() throws RecognitionException {
        try {
            int _type = Produce;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:925:8: ( ':produce' )
            // ANML.g:925:10: ':produce'
            {
            match(":produce"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Produce"

    // $ANTLR start "Use"
    public final void mUse() throws RecognitionException {
        try {
            int _type = Use;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:926:4: ( ':use' )
            // ANML.g:926:6: ':use'
            {
            match(":use"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Use"

    // $ANTLR start "Lend"
    public final void mLend() throws RecognitionException {
        try {
            int _type = Lend;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:927:5: ( ':lend' )
            // ANML.g:927:7: ':lend'
            {
            match(":lend"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Lend"

    // $ANTLR start "Change"
    public final void mChange() throws RecognitionException {
        try {
            int _type = Change;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:929:7: ( ':->' )
            // ANML.g:929:9: ':->'
            {
            match(":->"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Change"

    // $ANTLR start "When"
    public final void mWhen() throws RecognitionException {
        try {
            int _type = When;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:932:5: ( 'when' )
            // ANML.g:932:7: 'when'
            {
            match("when"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "When"

    // $ANTLR start "Else"
    public final void mElse() throws RecognitionException {
        try {
            int _type = Else;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:933:5: ( 'else' )
            // ANML.g:933:7: 'else'
            {
            match("else"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Else"

    // $ANTLR start "Exists"
    public final void mExists() throws RecognitionException {
        try {
            int _type = Exists;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:934:7: ( 'exists' )
            // ANML.g:934:9: 'exists'
            {
            match("exists"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Exists"

    // $ANTLR start "ForAll"
    public final void mForAll() throws RecognitionException {
        try {
            int _type = ForAll;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:935:7: ( 'forall' )
            // ANML.g:935:9: 'forall'
            {
            match("forall"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ForAll"

    // $ANTLR start "With"
    public final void mWith() throws RecognitionException {
        try {
            int _type = With;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:937:5: ( 'with' )
            // ANML.g:937:7: 'with'
            {
            match("with"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "With"

    // $ANTLR start "Within"
    public final void mWithin() throws RecognitionException {
        try {
            int _type = Within;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:938:7: ( 'in' )
            // ANML.g:938:9: 'in'
            {
            match("in"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Within"

    // $ANTLR start "Contains"
    public final void mContains() throws RecognitionException {
        try {
            int _type = Contains;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:939:9: ( 'contains' )
            // ANML.g:939:11: 'contains'
            {
            match("contains"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Contains"

    // $ANTLR start "Constant"
    public final void mConstant() throws RecognitionException {
        try {
            int _type = Constant;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:941:9: ( 'constant' | 'const' )
            int alt8=2;
            int LA8_0 = input.LA(1);

            if ( (LA8_0=='c') ) {
                int LA8_1 = input.LA(2);

                if ( (LA8_1=='o') ) {
                    int LA8_2 = input.LA(3);

                    if ( (LA8_2=='n') ) {
                        int LA8_3 = input.LA(4);

                        if ( (LA8_3=='s') ) {
                            int LA8_4 = input.LA(5);

                            if ( (LA8_4=='t') ) {
                                int LA8_5 = input.LA(6);

                                if ( (LA8_5=='a') ) {
                                    alt8=1;
                                }
                                else {
                                    alt8=2;}
                            }
                            else {
                                NoViableAltException nvae =
                                    new NoViableAltException("", 8, 4, input);

                                throw nvae;
                            }
                        }
                        else {
                            NoViableAltException nvae =
                                new NoViableAltException("", 8, 3, input);

                            throw nvae;
                        }
                    }
                    else {
                        NoViableAltException nvae =
                            new NoViableAltException("", 8, 2, input);

                        throw nvae;
                    }
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 8, 1, input);

                    throw nvae;
                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 8, 0, input);

                throw nvae;
            }
            switch (alt8) {
                case 1 :
                    // ANML.g:941:11: 'constant'
                    {
                    match("constant"); 


                    }
                    break;
                case 2 :
                    // ANML.g:941:24: 'const'
                    {
                    match("const"); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Constant"

    // $ANTLR start "Fluent"
    public final void mFluent() throws RecognitionException {
        try {
            int _type = Fluent;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:942:7: ( 'fluent' )
            // ANML.g:942:9: 'fluent'
            {
            match("fluent"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Fluent"

    // $ANTLR start "Function"
    public final void mFunction() throws RecognitionException {
        try {
            int _type = Function;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:943:9: ( 'function' )
            // ANML.g:943:11: 'function'
            {
            match("function"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Function"

    // $ANTLR start "Predicate"
    public final void mPredicate() throws RecognitionException {
        try {
            int _type = Predicate;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:944:10: ( 'predicate' )
            // ANML.g:944:12: 'predicate'
            {
            match("predicate"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Predicate"

    // $ANTLR start "Variable"
    public final void mVariable() throws RecognitionException {
        try {
            int _type = Variable;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:945:9: ( 'variable' | 'var' )
            int alt9=2;
            int LA9_0 = input.LA(1);

            if ( (LA9_0=='v') ) {
                int LA9_1 = input.LA(2);

                if ( (LA9_1=='a') ) {
                    int LA9_2 = input.LA(3);

                    if ( (LA9_2=='r') ) {
                        int LA9_3 = input.LA(4);

                        if ( (LA9_3=='i') ) {
                            alt9=1;
                        }
                        else {
                            alt9=2;}
                    }
                    else {
                        NoViableAltException nvae =
                            new NoViableAltException("", 9, 2, input);

                        throw nvae;
                    }
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 9, 1, input);

                    throw nvae;
                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 9, 0, input);

                throw nvae;
            }
            switch (alt9) {
                case 1 :
                    // ANML.g:945:11: 'variable'
                    {
                    match("variable"); 


                    }
                    break;
                case 2 :
                    // ANML.g:945:24: 'var'
                    {
                    match("var"); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Variable"

    // $ANTLR start "Type"
    public final void mType() throws RecognitionException {
        try {
            int _type = Type;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:946:5: ( 'type' )
            // ANML.g:946:7: 'type'
            {
            match("type"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Type"

    // $ANTLR start "Action"
    public final void mAction() throws RecognitionException {
        try {
            int _type = Action;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:947:7: ( 'action' )
            // ANML.g:947:9: 'action'
            {
            match("action"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Action"

    // $ANTLR start "Fact"
    public final void mFact() throws RecognitionException {
        try {
            int _type = Fact;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:948:5: ( 'fact' )
            // ANML.g:948:7: 'fact'
            {
            match("fact"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Fact"

    // $ANTLR start "Goal"
    public final void mGoal() throws RecognitionException {
        try {
            int _type = Goal;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:949:5: ( 'goal' )
            // ANML.g:949:7: 'goal'
            {
            match("goal"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Goal"

    // $ANTLR start "Decomposition"
    public final void mDecomposition() throws RecognitionException {
        try {
            int _type = Decomposition;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:950:14: ( ':decomposition' )
            // ANML.g:950:16: ':decomposition'
            {
            match(":decomposition"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Decomposition"

    // $ANTLR start "Ordered"
    public final void mOrdered() throws RecognitionException {
        try {
            int _type = Ordered;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:951:8: ( 'ordered' )
            // ANML.g:951:10: 'ordered'
            {
            match("ordered"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Ordered"

    // $ANTLR start "Unordered"
    public final void mUnordered() throws RecognitionException {
        try {
            int _type = Unordered;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:952:10: ( 'unordered' )
            // ANML.g:952:12: 'unordered'
            {
            match("unordered"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Unordered"

    // $ANTLR start "Boolean"
    public final void mBoolean() throws RecognitionException {
        try {
            int _type = Boolean;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:955:2: ( 'bool' | 'boolean' )
            int alt10=2;
            int LA10_0 = input.LA(1);

            if ( (LA10_0=='b') ) {
                int LA10_1 = input.LA(2);

                if ( (LA10_1=='o') ) {
                    int LA10_2 = input.LA(3);

                    if ( (LA10_2=='o') ) {
                        int LA10_3 = input.LA(4);

                        if ( (LA10_3=='l') ) {
                            int LA10_4 = input.LA(5);

                            if ( (LA10_4=='e') ) {
                                alt10=2;
                            }
                            else {
                                alt10=1;}
                        }
                        else {
                            NoViableAltException nvae =
                                new NoViableAltException("", 10, 3, input);

                            throw nvae;
                        }
                    }
                    else {
                        NoViableAltException nvae =
                            new NoViableAltException("", 10, 2, input);

                        throw nvae;
                    }
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 10, 1, input);

                    throw nvae;
                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 10, 0, input);

                throw nvae;
            }
            switch (alt10) {
                case 1 :
                    // ANML.g:955:4: 'bool'
                    {
                    match("bool"); 


                    }
                    break;
                case 2 :
                    // ANML.g:956:4: 'boolean'
                    {
                    match("boolean"); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Boolean"

    // $ANTLR start "Integer"
    public final void mInteger() throws RecognitionException {
        try {
            int _type = Integer;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:958:9: ( 'int' | 'integer' )
            int alt11=2;
            int LA11_0 = input.LA(1);

            if ( (LA11_0=='i') ) {
                int LA11_1 = input.LA(2);

                if ( (LA11_1=='n') ) {
                    int LA11_2 = input.LA(3);

                    if ( (LA11_2=='t') ) {
                        int LA11_3 = input.LA(4);

                        if ( (LA11_3=='e') ) {
                            alt11=2;
                        }
                        else {
                            alt11=1;}
                    }
                    else {
                        NoViableAltException nvae =
                            new NoViableAltException("", 11, 2, input);

                        throw nvae;
                    }
                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 11, 1, input);

                    throw nvae;
                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 11, 0, input);

                throw nvae;
            }
            switch (alt11) {
                case 1 :
                    // ANML.g:958:11: 'int'
                    {
                    match("int"); 


                    }
                    break;
                case 2 :
                    // ANML.g:958:19: 'integer'
                    {
                    match("integer"); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Integer"

    // $ANTLR start "Float"
    public final void mFloat() throws RecognitionException {
        try {
            int _type = Float;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:959:7: ( 'float' )
            // ANML.g:959:9: 'float'
            {
            match("float"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Float"

    // $ANTLR start "Symbol"
    public final void mSymbol() throws RecognitionException {
        try {
            int _type = Symbol;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:960:8: ( 'symbol' )
            // ANML.g:960:10: 'symbol'
            {
            match("symbol"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Symbol"

    // $ANTLR start "String"
    public final void mString() throws RecognitionException {
        try {
            int _type = String;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:961:8: ( 'string' )
            // ANML.g:961:10: 'string'
            {
            match("string"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "String"

    // $ANTLR start "Object"
    public final void mObject() throws RecognitionException {
        try {
            int _type = Object;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:962:8: ( 'object' )
            // ANML.g:962:10: 'object'
            {
            match("object"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Object"

    // $ANTLR start "Vector"
    public final void mVector() throws RecognitionException {
        try {
            int _type = Vector;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:964:8: ( 'vector' )
            // ANML.g:964:10: 'vector'
            {
            match("vector"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Vector"

    // $ANTLR start "Delta"
    public final void mDelta() throws RecognitionException {
        try {
            int _type = Delta;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:966:7: ( '^' )
            // ANML.g:966:9: '^'
            {
            match('^'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Delta"

    // $ANTLR start "Undefined"
    public final void mUndefined() throws RecognitionException {
        try {
            int _type = Undefined;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:968:10: ( 'undefined' | 'U' | 'UNDEFINED' | 'Undefined' )
            int alt12=4;
            int LA12_0 = input.LA(1);

            if ( (LA12_0=='u') ) {
                alt12=1;
            }
            else if ( (LA12_0=='U') ) {
                switch ( input.LA(2) ) {
                case 'N':
                    {
                    alt12=3;
                    }
                    break;
                case 'n':
                    {
                    alt12=4;
                    }
                    break;
                default:
                    alt12=2;}

            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 12, 0, input);

                throw nvae;
            }
            switch (alt12) {
                case 1 :
                    // ANML.g:968:12: 'undefined'
                    {
                    match("undefined"); 


                    }
                    break;
                case 2 :
                    // ANML.g:969:4: 'U'
                    {
                    match('U'); 

                    }
                    break;
                case 3 :
                    // ANML.g:969:10: 'UNDEFINED'
                    {
                    match("UNDEFINED"); 


                    }
                    break;
                case 4 :
                    // ANML.g:969:24: 'Undefined'
                    {
                    match("Undefined"); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Undefined"

    // $ANTLR start "All"
    public final void mAll() throws RecognitionException {
        try {
            int _type = All;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:971:4: ( 'all' )
            // ANML.g:971:6: 'all'
            {
            match("all"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "All"

    // $ANTLR start "Start"
    public final void mStart() throws RecognitionException {
        try {
            int _type = Start;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:972:6: ( 'start' )
            // ANML.g:972:8: 'start'
            {
            match("start"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Start"

    // $ANTLR start "End"
    public final void mEnd() throws RecognitionException {
        try {
            int _type = End;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:973:4: ( 'end' )
            // ANML.g:973:6: 'end'
            {
            match("end"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "End"

    // $ANTLR start "Duration"
    public final void mDuration() throws RecognitionException {
        try {
            int _type = Duration;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:974:9: ( 'duration' )
            // ANML.g:974:11: 'duration'
            {
            match("duration"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Duration"

    // $ANTLR start "Infinity"
    public final void mInfinity() throws RecognitionException {
        try {
            int _type = Infinity;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:975:9: ( 'infinity' | 'Infinity' | 'INFINITY' | 'infty' | 'INFTY' | 'inff' | 'INFF' )
            int alt13=7;
            alt13 = dfa13.predict(input);
            switch (alt13) {
                case 1 :
                    // ANML.g:975:11: 'infinity'
                    {
                    match("infinity"); 


                    }
                    break;
                case 2 :
                    // ANML.g:975:24: 'Infinity'
                    {
                    match("Infinity"); 


                    }
                    break;
                case 3 :
                    // ANML.g:975:37: 'INFINITY'
                    {
                    match("INFINITY"); 


                    }
                    break;
                case 4 :
                    // ANML.g:975:50: 'infty'
                    {
                    match("infty"); 


                    }
                    break;
                case 5 :
                    // ANML.g:975:60: 'INFTY'
                    {
                    match("INFTY"); 


                    }
                    break;
                case 6 :
                    // ANML.g:975:70: 'inff'
                    {
                    match("inff"); 


                    }
                    break;
                case 7 :
                    // ANML.g:975:79: 'INFF'
                    {
                    match("INFF"); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Infinity"

    // $ANTLR start "True"
    public final void mTrue() throws RecognitionException {
        try {
            int _type = True;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:979:5: ( ( 'T' | 'TRUE' | 'true' | 'True' ) )
            // ANML.g:979:7: ( 'T' | 'TRUE' | 'true' | 'True' )
            {
            // ANML.g:979:7: ( 'T' | 'TRUE' | 'true' | 'True' )
            int alt14=4;
            int LA14_0 = input.LA(1);

            if ( (LA14_0=='T') ) {
                switch ( input.LA(2) ) {
                case 'R':
                    {
                    alt14=2;
                    }
                    break;
                case 'r':
                    {
                    alt14=4;
                    }
                    break;
                default:
                    alt14=1;}

            }
            else if ( (LA14_0=='t') ) {
                alt14=3;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 14, 0, input);

                throw nvae;
            }
            switch (alt14) {
                case 1 :
                    // ANML.g:979:8: 'T'
                    {
                    match('T'); 

                    }
                    break;
                case 2 :
                    // ANML.g:979:14: 'TRUE'
                    {
                    match("TRUE"); 


                    }
                    break;
                case 3 :
                    // ANML.g:979:23: 'true'
                    {
                    match("true"); 


                    }
                    break;
                case 4 :
                    // ANML.g:979:32: 'True'
                    {
                    match("True"); 


                    }
                    break;

            }


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "True"

    // $ANTLR start "False"
    public final void mFalse() throws RecognitionException {
        try {
            int _type = False;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:980:6: ( ( 'F' | 'FALSE' | 'false' | 'False' ) )
            // ANML.g:980:8: ( 'F' | 'FALSE' | 'false' | 'False' )
            {
            // ANML.g:980:8: ( 'F' | 'FALSE' | 'false' | 'False' )
            int alt15=4;
            int LA15_0 = input.LA(1);

            if ( (LA15_0=='F') ) {
                switch ( input.LA(2) ) {
                case 'A':
                    {
                    alt15=2;
                    }
                    break;
                case 'a':
                    {
                    alt15=4;
                    }
                    break;
                default:
                    alt15=1;}

            }
            else if ( (LA15_0=='f') ) {
                alt15=3;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 15, 0, input);

                throw nvae;
            }
            switch (alt15) {
                case 1 :
                    // ANML.g:980:9: 'F'
                    {
                    match('F'); 

                    }
                    break;
                case 2 :
                    // ANML.g:980:15: 'FALSE'
                    {
                    match("FALSE"); 


                    }
                    break;
                case 3 :
                    // ANML.g:980:25: 'false'
                    {
                    match("false"); 


                    }
                    break;
                case 4 :
                    // ANML.g:980:35: 'False'
                    {
                    match("False"); 


                    }
                    break;

            }


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "False"

    // $ANTLR start "INT"
    public final void mINT() throws RecognitionException {
        try {
            int _type = INT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:981:4: ( ( DIGIT )+ )
            // ANML.g:981:6: ( DIGIT )+
            {
            // ANML.g:981:6: ( DIGIT )+
            int cnt16=0;
            loop16:
            do {
                int alt16=2;
                int LA16_0 = input.LA(1);

                if ( ((LA16_0>='0' && LA16_0<='9')) ) {
                    alt16=1;
                }


                switch (alt16) {
            	case 1 :
            	    // ANML.g:981:6: DIGIT
            	    {
            	    mDIGIT(); 

            	    }
            	    break;

            	default :
            	    if ( cnt16 >= 1 ) break loop16;
                        EarlyExitException eee =
                            new EarlyExitException(16, input);
                        throw eee;
                }
                cnt16++;
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "INT"

    // $ANTLR start "FLOAT"
    public final void mFLOAT() throws RecognitionException {
        try {
            int _type = FLOAT;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:983:2: ( ( DIGIT )+ Dot ( DIGIT )+ | ( DIGIT )+ 'f' )
            int alt20=2;
            alt20 = dfa20.predict(input);
            switch (alt20) {
                case 1 :
                    // ANML.g:983:4: ( DIGIT )+ Dot ( DIGIT )+
                    {
                    // ANML.g:983:4: ( DIGIT )+
                    int cnt17=0;
                    loop17:
                    do {
                        int alt17=2;
                        int LA17_0 = input.LA(1);

                        if ( ((LA17_0>='0' && LA17_0<='9')) ) {
                            alt17=1;
                        }


                        switch (alt17) {
                    	case 1 :
                    	    // ANML.g:983:4: DIGIT
                    	    {
                    	    mDIGIT(); 

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt17 >= 1 ) break loop17;
                                EarlyExitException eee =
                                    new EarlyExitException(17, input);
                                throw eee;
                        }
                        cnt17++;
                    } while (true);

                    mDot(); 
                    // ANML.g:983:15: ( DIGIT )+
                    int cnt18=0;
                    loop18:
                    do {
                        int alt18=2;
                        int LA18_0 = input.LA(1);

                        if ( ((LA18_0>='0' && LA18_0<='9')) ) {
                            alt18=1;
                        }


                        switch (alt18) {
                    	case 1 :
                    	    // ANML.g:983:15: DIGIT
                    	    {
                    	    mDIGIT(); 

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt18 >= 1 ) break loop18;
                                EarlyExitException eee =
                                    new EarlyExitException(18, input);
                                throw eee;
                        }
                        cnt18++;
                    } while (true);


                    }
                    break;
                case 2 :
                    // ANML.g:984:4: ( DIGIT )+ 'f'
                    {
                    // ANML.g:984:4: ( DIGIT )+
                    int cnt19=0;
                    loop19:
                    do {
                        int alt19=2;
                        int LA19_0 = input.LA(1);

                        if ( ((LA19_0>='0' && LA19_0<='9')) ) {
                            alt19=1;
                        }


                        switch (alt19) {
                    	case 1 :
                    	    // ANML.g:984:4: DIGIT
                    	    {
                    	    mDIGIT(); 

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt19 >= 1 ) break loop19;
                                EarlyExitException eee =
                                    new EarlyExitException(19, input);
                                throw eee;
                        }
                        cnt19++;
                    } while (true);

                    match('f'); 

                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "FLOAT"

    // $ANTLR start "STRING"
    public final void mSTRING() throws RecognitionException {
        try {
            int _type = STRING;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:986:7: ( '\"' ( ESC )* '\"' )
            // ANML.g:986:10: '\"' ( ESC )* '\"'
            {
            match('\"'); 
            // ANML.g:986:14: ( ESC )*
            loop21:
            do {
                int alt21=2;
                int LA21_0 = input.LA(1);

                if ( ((LA21_0>='\u0000' && LA21_0<='!')||(LA21_0>='#' && LA21_0<='\uFFFF')) ) {
                    alt21=1;
                }


                switch (alt21) {
            	case 1 :
            	    // ANML.g:986:14: ESC
            	    {
            	    mESC(); 

            	    }
            	    break;

            	default :
            	    break loop21;
                }
            } while (true);

            match('\"'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "STRING"

    // $ANTLR start "ID"
    public final void mID() throws RecognitionException {
        try {
            int _type = ID;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:989:4: ( LETTER ( LETTER | DIGIT | '_' )* )
            // ANML.g:989:6: LETTER ( LETTER | DIGIT | '_' )*
            {
            mLETTER(); 
            // ANML.g:989:13: ( LETTER | DIGIT | '_' )*
            loop22:
            do {
                int alt22=2;
                int LA22_0 = input.LA(1);

                if ( ((LA22_0>='0' && LA22_0<='9')||(LA22_0>='A' && LA22_0<='Z')||LA22_0=='_'||(LA22_0>='a' && LA22_0<='z')) ) {
                    alt22=1;
                }


                switch (alt22) {
            	case 1 :
            	    // ANML.g:
            	    {
            	    if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    break loop22;
                }
            } while (true);


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "ID"

    // $ANTLR start "ESC"
    public final void mESC() throws RecognitionException {
        try {
            // ANML.g:991:14: ( '\\\\' . | ~ '\\\"' )
            int alt23=2;
            int LA23_0 = input.LA(1);

            if ( (LA23_0=='\\') ) {
                int LA23_1 = input.LA(2);

                if ( ((LA23_1>='\u0000' && LA23_1<='\uFFFF')) ) {
                    alt23=1;
                }
                else {
                    alt23=2;}
            }
            else if ( ((LA23_0>='\u0000' && LA23_0<='!')||(LA23_0>='#' && LA23_0<='[')||(LA23_0>=']' && LA23_0<='\uFFFF')) ) {
                alt23=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 23, 0, input);

                throw nvae;
            }
            switch (alt23) {
                case 1 :
                    // ANML.g:991:16: '\\\\' .
                    {
                    match('\\'); 
                    matchAny(); 

                    }
                    break;
                case 2 :
                    // ANML.g:991:24: ~ '\\\"'
                    {
                    if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='\uFFFF') ) {
                        input.consume();

                    }
                    else {
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        recover(mse);
                        throw mse;}


                    }
                    break;

            }
        }
        finally {
        }
    }
    // $ANTLR end "ESC"

    // $ANTLR start "LETTER"
    public final void mLETTER() throws RecognitionException {
        try {
            // ANML.g:992:18: ( 'a' .. 'z' | 'A' .. 'Z' )
            // ANML.g:
            {
            if ( (input.LA(1)>='A' && input.LA(1)<='Z')||(input.LA(1)>='a' && input.LA(1)<='z') ) {
                input.consume();

            }
            else {
                MismatchedSetException mse = new MismatchedSetException(null,input);
                recover(mse);
                throw mse;}


            }

        }
        finally {
        }
    }
    // $ANTLR end "LETTER"

    // $ANTLR start "DIGIT"
    public final void mDIGIT() throws RecognitionException {
        try {
            // ANML.g:993:16: ( '0' .. '9' )
            // ANML.g:993:19: '0' .. '9'
            {
            matchRange('0','9'); 

            }

        }
        finally {
        }
    }
    // $ANTLR end "DIGIT"

    // $ANTLR start "WS"
    public final void mWS() throws RecognitionException {
        try {
            int _type = WS;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:995:5: ( ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' )+ )
            // ANML.g:995:8: ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' )+
            {
            // ANML.g:995:8: ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' )+
            int cnt24=0;
            loop24:
            do {
                int alt24=2;
                int LA24_0 = input.LA(1);

                if ( ((LA24_0>='\t' && LA24_0<='\n')||(LA24_0>='\f' && LA24_0<='\r')||LA24_0==' ') ) {
                    alt24=1;
                }


                switch (alt24) {
            	case 1 :
            	    // ANML.g:
            	    {
            	    if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||(input.LA(1)>='\f' && input.LA(1)<='\r')||input.LA(1)==' ' ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    if ( cnt24 >= 1 ) break loop24;
                        EarlyExitException eee =
                            new EarlyExitException(24, input);
                        throw eee;
                }
                cnt24++;
            } while (true);

            _channel=HIDDEN;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "WS"

    // $ANTLR start "SLC"
    public final void mSLC() throws RecognitionException {
        try {
            int _type = SLC;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:996:5: ( '//' (~ '\\n' )* '\\n' )
            // ANML.g:996:7: '//' (~ '\\n' )* '\\n'
            {
            match("//"); 

            // ANML.g:996:12: (~ '\\n' )*
            loop25:
            do {
                int alt25=2;
                int LA25_0 = input.LA(1);

                if ( ((LA25_0>='\u0000' && LA25_0<='\t')||(LA25_0>='\u000B' && LA25_0<='\uFFFF')) ) {
                    alt25=1;
                }


                switch (alt25) {
            	case 1 :
            	    // ANML.g:996:13: ~ '\\n'
            	    {
            	    if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\uFFFF') ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;

            	default :
            	    break loop25;
                }
            } while (true);

            match('\n'); 
            _channel=HIDDEN;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "SLC"

    // $ANTLR start "MLC"
    public final void mMLC() throws RecognitionException {
        try {
            int _type = MLC;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:997:5: ( '/*' (~ '*' | ( '*' )+ (~ ( '*' | '/' ) ) )* ( '*' )+ '/' )
            // ANML.g:997:7: '/*' (~ '*' | ( '*' )+ (~ ( '*' | '/' ) ) )* ( '*' )+ '/'
            {
            match("/*"); 

            // ANML.g:997:12: (~ '*' | ( '*' )+ (~ ( '*' | '/' ) ) )*
            loop27:
            do {
                int alt27=3;
                alt27 = dfa27.predict(input);
                switch (alt27) {
            	case 1 :
            	    // ANML.g:997:13: ~ '*'
            	    {
            	    if ( (input.LA(1)>='\u0000' && input.LA(1)<=')')||(input.LA(1)>='+' && input.LA(1)<='\uFFFF') ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }
            	    break;
            	case 2 :
            	    // ANML.g:997:20: ( '*' )+ (~ ( '*' | '/' ) )
            	    {
            	    // ANML.g:997:20: ( '*' )+
            	    int cnt26=0;
            	    loop26:
            	    do {
            	        int alt26=2;
            	        int LA26_0 = input.LA(1);

            	        if ( (LA26_0=='*') ) {
            	            alt26=1;
            	        }


            	        switch (alt26) {
            	    	case 1 :
            	    	    // ANML.g:997:20: '*'
            	    	    {
            	    	    match('*'); 

            	    	    }
            	    	    break;

            	    	default :
            	    	    if ( cnt26 >= 1 ) break loop26;
            	                EarlyExitException eee =
            	                    new EarlyExitException(26, input);
            	                throw eee;
            	        }
            	        cnt26++;
            	    } while (true);

            	    // ANML.g:997:24: (~ ( '*' | '/' ) )
            	    // ANML.g:997:25: ~ ( '*' | '/' )
            	    {
            	    if ( (input.LA(1)>='\u0000' && input.LA(1)<=')')||(input.LA(1)>='+' && input.LA(1)<='.')||(input.LA(1)>='0' && input.LA(1)<='\uFFFF') ) {
            	        input.consume();

            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        recover(mse);
            	        throw mse;}


            	    }


            	    }
            	    break;

            	default :
            	    break loop27;
                }
            } while (true);

            // ANML.g:997:39: ( '*' )+
            int cnt28=0;
            loop28:
            do {
                int alt28=2;
                int LA28_0 = input.LA(1);

                if ( (LA28_0=='*') ) {
                    alt28=1;
                }


                switch (alt28) {
            	case 1 :
            	    // ANML.g:997:39: '*'
            	    {
            	    match('*'); 

            	    }
            	    break;

            	default :
            	    if ( cnt28 >= 1 ) break loop28;
                        EarlyExitException eee =
                            new EarlyExitException(28, input);
                        throw eee;
                }
                cnt28++;
            } while (true);

            match('/'); 
            _channel=HIDDEN;

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "MLC"

    // $ANTLR start "Dot"
    public final void mDot() throws RecognitionException {
        try {
            int _type = Dot;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:999:4: ( '.' )
            // ANML.g:999:6: '.'
            {
            match('.'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Dot"

    // $ANTLR start "Dots"
    public final void mDots() throws RecognitionException {
        try {
            int _type = Dots;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:1000:5: ( '...' )
            // ANML.g:1000:7: '...'
            {
            match("..."); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Dots"

    // $ANTLR start "Comma"
    public final void mComma() throws RecognitionException {
        try {
            int _type = Comma;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:1001:6: ( ',' )
            // ANML.g:1001:8: ','
            {
            match(','); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Comma"

    // $ANTLR start "Semi"
    public final void mSemi() throws RecognitionException {
        try {
            int _type = Semi;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:1002:5: ( ';' )
            // ANML.g:1002:7: ';'
            {
            match(';'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Semi"

    // $ANTLR start "Colon"
    public final void mColon() throws RecognitionException {
        try {
            int _type = Colon;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:1003:6: ( ':' )
            // ANML.g:1003:8: ':'
            {
            match(':'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Colon"

    // $ANTLR start "LeftP"
    public final void mLeftP() throws RecognitionException {
        try {
            int _type = LeftP;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:1004:6: ( '(' )
            // ANML.g:1004:8: '('
            {
            match('('); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LeftP"

    // $ANTLR start "RightP"
    public final void mRightP() throws RecognitionException {
        try {
            int _type = RightP;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:1005:7: ( ')' )
            // ANML.g:1005:9: ')'
            {
            match(')'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "RightP"

    // $ANTLR start "LeftC"
    public final void mLeftC() throws RecognitionException {
        try {
            int _type = LeftC;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:1006:6: ( '{' )
            // ANML.g:1006:8: '{'
            {
            match('{'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LeftC"

    // $ANTLR start "RightC"
    public final void mRightC() throws RecognitionException {
        try {
            int _type = RightC;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:1007:7: ( '}' )
            // ANML.g:1007:9: '}'
            {
            match('}'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "RightC"

    // $ANTLR start "LeftB"
    public final void mLeftB() throws RecognitionException {
        try {
            int _type = LeftB;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:1008:6: ( '[' )
            // ANML.g:1008:8: '['
            {
            match('['); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "LeftB"

    // $ANTLR start "RightB"
    public final void mRightB() throws RecognitionException {
        try {
            int _type = RightB;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:1009:7: ( ']' )
            // ANML.g:1009:9: ']'
            {
            match(']'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "RightB"

    // $ANTLR start "Undefine"
    public final void mUndefine() throws RecognitionException {
        try {
            int _type = Undefine;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:1010:9: ( ':_' )
            // ANML.g:1010:11: ':_'
            {
            match(":_"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Undefine"

    // $ANTLR start "Skip"
    public final void mSkip() throws RecognitionException {
        try {
            int _type = Skip;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // ANML.g:1011:5: ( '_' )
            // ANML.g:1011:7: '_'
            {
            match('_'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
    // $ANTLR end "Skip"

    public void mTokens() throws RecognitionException {
        // ANML.g:1:8: ( NotLog | AndLog | OrLog | XorLog | EqualLog | Implies | NotBit | AndBit | OrBit | XorBit | Times | Divide | Plus | Minus | Equal | NotEqual | LessThan | LessThanE | GreaterThan | GreaterThanE | SetAssign | Assign | Consume | Produce | Use | Lend | Change | When | Else | Exists | ForAll | With | Within | Contains | Constant | Fluent | Function | Predicate | Variable | Type | Action | Fact | Goal | Decomposition | Ordered | Unordered | Boolean | Integer | Float | Symbol | String | Object | Vector | Delta | Undefined | All | Start | End | Duration | Infinity | True | False | INT | FLOAT | STRING | ID | WS | SLC | MLC | Dot | Dots | Comma | Semi | Colon | LeftP | RightP | LeftC | RightC | LeftB | RightB | Undefine | Skip )
        int alt29=82;
        alt29 = dfa29.predict(input);
        switch (alt29) {
            case 1 :
                // ANML.g:1:10: NotLog
                {
                mNotLog(); 

                }
                break;
            case 2 :
                // ANML.g:1:17: AndLog
                {
                mAndLog(); 

                }
                break;
            case 3 :
                // ANML.g:1:24: OrLog
                {
                mOrLog(); 

                }
                break;
            case 4 :
                // ANML.g:1:30: XorLog
                {
                mXorLog(); 

                }
                break;
            case 5 :
                // ANML.g:1:37: EqualLog
                {
                mEqualLog(); 

                }
                break;
            case 6 :
                // ANML.g:1:46: Implies
                {
                mImplies(); 

                }
                break;
            case 7 :
                // ANML.g:1:54: NotBit
                {
                mNotBit(); 

                }
                break;
            case 8 :
                // ANML.g:1:61: AndBit
                {
                mAndBit(); 

                }
                break;
            case 9 :
                // ANML.g:1:68: OrBit
                {
                mOrBit(); 

                }
                break;
            case 10 :
                // ANML.g:1:74: XorBit
                {
                mXorBit(); 

                }
                break;
            case 11 :
                // ANML.g:1:81: Times
                {
                mTimes(); 

                }
                break;
            case 12 :
                // ANML.g:1:87: Divide
                {
                mDivide(); 

                }
                break;
            case 13 :
                // ANML.g:1:94: Plus
                {
                mPlus(); 

                }
                break;
            case 14 :
                // ANML.g:1:99: Minus
                {
                mMinus(); 

                }
                break;
            case 15 :
                // ANML.g:1:105: Equal
                {
                mEqual(); 

                }
                break;
            case 16 :
                // ANML.g:1:111: NotEqual
                {
                mNotEqual(); 

                }
                break;
            case 17 :
                // ANML.g:1:120: LessThan
                {
                mLessThan(); 

                }
                break;
            case 18 :
                // ANML.g:1:129: LessThanE
                {
                mLessThanE(); 

                }
                break;
            case 19 :
                // ANML.g:1:139: GreaterThan
                {
                mGreaterThan(); 

                }
                break;
            case 20 :
                // ANML.g:1:151: GreaterThanE
                {
                mGreaterThanE(); 

                }
                break;
            case 21 :
                // ANML.g:1:164: SetAssign
                {
                mSetAssign(); 

                }
                break;
            case 22 :
                // ANML.g:1:174: Assign
                {
                mAssign(); 

                }
                break;
            case 23 :
                // ANML.g:1:181: Consume
                {
                mConsume(); 

                }
                break;
            case 24 :
                // ANML.g:1:189: Produce
                {
                mProduce(); 

                }
                break;
            case 25 :
                // ANML.g:1:197: Use
                {
                mUse(); 

                }
                break;
            case 26 :
                // ANML.g:1:201: Lend
                {
                mLend(); 

                }
                break;
            case 27 :
                // ANML.g:1:206: Change
                {
                mChange(); 

                }
                break;
            case 28 :
                // ANML.g:1:213: When
                {
                mWhen(); 

                }
                break;
            case 29 :
                // ANML.g:1:218: Else
                {
                mElse(); 

                }
                break;
            case 30 :
                // ANML.g:1:223: Exists
                {
                mExists(); 

                }
                break;
            case 31 :
                // ANML.g:1:230: ForAll
                {
                mForAll(); 

                }
                break;
            case 32 :
                // ANML.g:1:237: With
                {
                mWith(); 

                }
                break;
            case 33 :
                // ANML.g:1:242: Within
                {
                mWithin(); 

                }
                break;
            case 34 :
                // ANML.g:1:249: Contains
                {
                mContains(); 

                }
                break;
            case 35 :
                // ANML.g:1:258: Constant
                {
                mConstant(); 

                }
                break;
            case 36 :
                // ANML.g:1:267: Fluent
                {
                mFluent(); 

                }
                break;
            case 37 :
                // ANML.g:1:274: Function
                {
                mFunction(); 

                }
                break;
            case 38 :
                // ANML.g:1:283: Predicate
                {
                mPredicate(); 

                }
                break;
            case 39 :
                // ANML.g:1:293: Variable
                {
                mVariable(); 

                }
                break;
            case 40 :
                // ANML.g:1:302: Type
                {
                mType(); 

                }
                break;
            case 41 :
                // ANML.g:1:307: Action
                {
                mAction(); 

                }
                break;
            case 42 :
                // ANML.g:1:314: Fact
                {
                mFact(); 

                }
                break;
            case 43 :
                // ANML.g:1:319: Goal
                {
                mGoal(); 

                }
                break;
            case 44 :
                // ANML.g:1:324: Decomposition
                {
                mDecomposition(); 

                }
                break;
            case 45 :
                // ANML.g:1:338: Ordered
                {
                mOrdered(); 

                }
                break;
            case 46 :
                // ANML.g:1:346: Unordered
                {
                mUnordered(); 

                }
                break;
            case 47 :
                // ANML.g:1:356: Boolean
                {
                mBoolean(); 

                }
                break;
            case 48 :
                // ANML.g:1:364: Integer
                {
                mInteger(); 

                }
                break;
            case 49 :
                // ANML.g:1:372: Float
                {
                mFloat(); 

                }
                break;
            case 50 :
                // ANML.g:1:378: Symbol
                {
                mSymbol(); 

                }
                break;
            case 51 :
                // ANML.g:1:385: String
                {
                mString(); 

                }
                break;
            case 52 :
                // ANML.g:1:392: Object
                {
                mObject(); 

                }
                break;
            case 53 :
                // ANML.g:1:399: Vector
                {
                mVector(); 

                }
                break;
            case 54 :
                // ANML.g:1:406: Delta
                {
                mDelta(); 

                }
                break;
            case 55 :
                // ANML.g:1:412: Undefined
                {
                mUndefined(); 

                }
                break;
            case 56 :
                // ANML.g:1:422: All
                {
                mAll(); 

                }
                break;
            case 57 :
                // ANML.g:1:426: Start
                {
                mStart(); 

                }
                break;
            case 58 :
                // ANML.g:1:432: End
                {
                mEnd(); 

                }
                break;
            case 59 :
                // ANML.g:1:436: Duration
                {
                mDuration(); 

                }
                break;
            case 60 :
                // ANML.g:1:445: Infinity
                {
                mInfinity(); 

                }
                break;
            case 61 :
                // ANML.g:1:454: True
                {
                mTrue(); 

                }
                break;
            case 62 :
                // ANML.g:1:459: False
                {
                mFalse(); 

                }
                break;
            case 63 :
                // ANML.g:1:465: INT
                {
                mINT(); 

                }
                break;
            case 64 :
                // ANML.g:1:469: FLOAT
                {
                mFLOAT(); 

                }
                break;
            case 65 :
                // ANML.g:1:475: STRING
                {
                mSTRING(); 

                }
                break;
            case 66 :
                // ANML.g:1:482: ID
                {
                mID(); 

                }
                break;
            case 67 :
                // ANML.g:1:485: WS
                {
                mWS(); 

                }
                break;
            case 68 :
                // ANML.g:1:488: SLC
                {
                mSLC(); 

                }
                break;
            case 69 :
                // ANML.g:1:492: MLC
                {
                mMLC(); 

                }
                break;
            case 70 :
                // ANML.g:1:496: Dot
                {
                mDot(); 

                }
                break;
            case 71 :
                // ANML.g:1:500: Dots
                {
                mDots(); 

                }
                break;
            case 72 :
                // ANML.g:1:505: Comma
                {
                mComma(); 

                }
                break;
            case 73 :
                // ANML.g:1:511: Semi
                {
                mSemi(); 

                }
                break;
            case 74 :
                // ANML.g:1:516: Colon
                {
                mColon(); 

                }
                break;
            case 75 :
                // ANML.g:1:522: LeftP
                {
                mLeftP(); 

                }
                break;
            case 76 :
                // ANML.g:1:528: RightP
                {
                mRightP(); 

                }
                break;
            case 77 :
                // ANML.g:1:535: LeftC
                {
                mLeftC(); 

                }
                break;
            case 78 :
                // ANML.g:1:541: RightC
                {
                mRightC(); 

                }
                break;
            case 79 :
                // ANML.g:1:548: LeftB
                {
                mLeftB(); 

                }
                break;
            case 80 :
                // ANML.g:1:554: RightB
                {
                mRightB(); 

                }
                break;
            case 81 :
                // ANML.g:1:561: Undefine
                {
                mUndefine(); 

                }
                break;
            case 82 :
                // ANML.g:1:570: Skip
                {
                mSkip(); 

                }
                break;

        }

    }


    protected DFA13 dfa13 = new DFA13(this);
    protected DFA20 dfa20 = new DFA20(this);
    protected DFA27 dfa27 = new DFA27(this);
    protected DFA29 dfa29 = new DFA29(this);
    static final String DFA13_eotS =
        "\16\uffff";
    static final String DFA13_eofS =
        "\16\uffff";
    static final String DFA13_minS =
        "\1\111\1\156\1\116\1\146\1\uffff\1\106\1\146\1\106\6\uffff";
    static final String DFA13_maxS =
        "\1\151\2\156\1\146\1\uffff\1\106\1\164\1\124\6\uffff";
    static final String DFA13_acceptS =
        "\4\uffff\1\2\3\uffff\1\1\1\4\1\6\1\3\1\5\1\7";
    static final String DFA13_specialS =
        "\16\uffff}>";
    static final String[] DFA13_transitionS = {
            "\1\2\37\uffff\1\1",
            "\1\3",
            "\1\5\37\uffff\1\4",
            "\1\6",
            "",
            "\1\7",
            "\1\12\2\uffff\1\10\12\uffff\1\11",
            "\1\15\2\uffff\1\13\12\uffff\1\14",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA13_eot = DFA.unpackEncodedString(DFA13_eotS);
    static final short[] DFA13_eof = DFA.unpackEncodedString(DFA13_eofS);
    static final char[] DFA13_min = DFA.unpackEncodedStringToUnsignedChars(DFA13_minS);
    static final char[] DFA13_max = DFA.unpackEncodedStringToUnsignedChars(DFA13_maxS);
    static final short[] DFA13_accept = DFA.unpackEncodedString(DFA13_acceptS);
    static final short[] DFA13_special = DFA.unpackEncodedString(DFA13_specialS);
    static final short[][] DFA13_transition;

    static {
        int numStates = DFA13_transitionS.length;
        DFA13_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA13_transition[i] = DFA.unpackEncodedString(DFA13_transitionS[i]);
        }
    }

    class DFA13 extends DFA {

        public DFA13(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 13;
            this.eot = DFA13_eot;
            this.eof = DFA13_eof;
            this.min = DFA13_min;
            this.max = DFA13_max;
            this.accept = DFA13_accept;
            this.special = DFA13_special;
            this.transition = DFA13_transition;
        }
        public String getDescription() {
            return "975:1: Infinity : ( 'infinity' | 'Infinity' | 'INFINITY' | 'infty' | 'INFTY' | 'inff' | 'INFF' );";
        }
    }
    static final String DFA20_eotS =
        "\4\uffff";
    static final String DFA20_eofS =
        "\4\uffff";
    static final String DFA20_minS =
        "\1\60\1\56\2\uffff";
    static final String DFA20_maxS =
        "\1\71\1\146\2\uffff";
    static final String DFA20_acceptS =
        "\2\uffff\1\1\1\2";
    static final String DFA20_specialS =
        "\4\uffff}>";
    static final String[] DFA20_transitionS = {
            "\12\1",
            "\1\2\1\uffff\12\1\54\uffff\1\3",
            "",
            ""
    };

    static final short[] DFA20_eot = DFA.unpackEncodedString(DFA20_eotS);
    static final short[] DFA20_eof = DFA.unpackEncodedString(DFA20_eofS);
    static final char[] DFA20_min = DFA.unpackEncodedStringToUnsignedChars(DFA20_minS);
    static final char[] DFA20_max = DFA.unpackEncodedStringToUnsignedChars(DFA20_maxS);
    static final short[] DFA20_accept = DFA.unpackEncodedString(DFA20_acceptS);
    static final short[] DFA20_special = DFA.unpackEncodedString(DFA20_specialS);
    static final short[][] DFA20_transition;

    static {
        int numStates = DFA20_transitionS.length;
        DFA20_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA20_transition[i] = DFA.unpackEncodedString(DFA20_transitionS[i]);
        }
    }

    class DFA20 extends DFA {

        public DFA20(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 20;
            this.eot = DFA20_eot;
            this.eof = DFA20_eof;
            this.min = DFA20_min;
            this.max = DFA20_max;
            this.accept = DFA20_accept;
            this.special = DFA20_special;
            this.transition = DFA20_transition;
        }
        public String getDescription() {
            return "982:1: FLOAT : ( ( DIGIT )+ Dot ( DIGIT )+ | ( DIGIT )+ 'f' );";
        }
    }
    static final String DFA27_eotS =
        "\5\uffff";
    static final String DFA27_eofS =
        "\5\uffff";
    static final String DFA27_minS =
        "\2\0\3\uffff";
    static final String DFA27_maxS =
        "\2\uffff\3\uffff";
    static final String DFA27_acceptS =
        "\2\uffff\1\1\1\2\1\3";
    static final String DFA27_specialS =
        "\1\1\1\0\3\uffff}>";
    static final String[] DFA27_transitionS = {
            "\52\2\1\1\uffd5\2",
            "\52\3\1\1\4\3\1\4\uffd0\3",
            "",
            "",
            ""
    };

    static final short[] DFA27_eot = DFA.unpackEncodedString(DFA27_eotS);
    static final short[] DFA27_eof = DFA.unpackEncodedString(DFA27_eofS);
    static final char[] DFA27_min = DFA.unpackEncodedStringToUnsignedChars(DFA27_minS);
    static final char[] DFA27_max = DFA.unpackEncodedStringToUnsignedChars(DFA27_maxS);
    static final short[] DFA27_accept = DFA.unpackEncodedString(DFA27_acceptS);
    static final short[] DFA27_special = DFA.unpackEncodedString(DFA27_specialS);
    static final short[][] DFA27_transition;

    static {
        int numStates = DFA27_transitionS.length;
        DFA27_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA27_transition[i] = DFA.unpackEncodedString(DFA27_transitionS[i]);
        }
    }

    class DFA27 extends DFA {

        public DFA27(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 27;
            this.eot = DFA27_eot;
            this.eof = DFA27_eof;
            this.min = DFA27_min;
            this.max = DFA27_max;
            this.accept = DFA27_accept;
            this.special = DFA27_special;
            this.transition = DFA27_transition;
        }
        public String getDescription() {
            return "()* loopback of 997:12: (~ '*' | ( '*' )+ (~ ( '*' | '/' ) ) )*";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            IntStream input = _input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA27_1 = input.LA(1);

                        s = -1;
                        if ( ((LA27_1>='\u0000' && LA27_1<=')')||(LA27_1>='+' && LA27_1<='.')||(LA27_1>='0' && LA27_1<='\uFFFF')) ) {s = 3;}

                        else if ( (LA27_1=='*') ) {s = 1;}

                        else if ( (LA27_1=='/') ) {s = 4;}

                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA27_0 = input.LA(1);

                        s = -1;
                        if ( (LA27_0=='*') ) {s = 1;}

                        else if ( ((LA27_0>='\u0000' && LA27_0<=')')||(LA27_0>='+' && LA27_0<='\uFFFF')) ) {s = 2;}

                        if ( s>=0 ) return s;
                        break;
            }
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 27, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA29_eotS =
        "\1\uffff\14\52\1\124\2\uffff\1\124\1\uffff\1\127\3\uffff\1\131\1"+
        "\133\1\145\12\52\1\uffff\1\171\1\52\1\175\1\u0080\1\u0081\3\uffff"+
        "\1\u0084\11\uffff\10\52\1\u008e\1\52\2\u008e\11\52\1\u009b\6\52"+
        "\24\uffff\23\52\1\uffff\3\52\1\uffff\2\52\5\uffff\3\u00be\1\u00bf"+
        "\1\52\1\u00c1\2\u00bf\1\52\1\uffff\1\52\3\u00c4\3\52\1\u00c8\1\u00c9"+
        "\1\52\1\u00cc\1\52\1\uffff\20\52\1\u00e4\21\52\2\uffff\1\52\1\uffff"+
        "\2\52\1\uffff\1\52\1\u00fa\1\52\2\uffff\2\52\1\uffff\2\52\1\u0100"+
        "\7\52\1\u0100\1\u0108\1\u0109\4\52\1\u010e\5\52\1\uffff\1\52\1\u0115"+
        "\1\175\1\u0116\2\52\1\u011a\6\52\2\175\6\52\1\uffff\4\52\1\u0100"+
        "\1\uffff\6\52\1\u0100\2\uffff\2\52\1\u0133\1\52\1\uffff\1\u0080"+
        "\1\52\1\u0137\3\52\2\uffff\3\52\1\uffff\2\52\1\u0140\3\52\2\u0080"+
        "\1\u0144\1\52\1\u0146\1\u00c9\1\u0147\3\52\2\u00c9\4\52\1\u014f"+
        "\1\u0150\1\uffff\3\52\1\uffff\2\52\1\u0156\3\52\1\u015a\1\u015b"+
        "\1\uffff\3\52\1\uffff\1\u015f\2\uffff\1\u0160\1\u00cc\1\52\2\u0160"+
        "\2\52\2\uffff\5\52\1\uffff\2\52\1\u011a\2\uffff\3\52\2\uffff\3\u0100"+
        "\1\u016e\1\u016f\1\u0137\1\52\1\u00e4\4\52\1\u0175\2\uffff\1\u0176"+
        "\1\u0177\3\171\3\uffff";
    static final String DFA29_eofS =
        "\u0178\uffff";
    static final String DFA29_minS =
        "\1\11\1\157\1\117\1\143\1\116\1\142\1\122\1\157\1\117\1\154\1\146"+
        "\1\121\1\115\1\46\2\uffff\1\75\1\uffff\1\52\3\uffff\2\75\1\55\1"+
        "\150\1\141\1\157\1\162\1\141\1\162\1\157\1\156\1\157\1\164\1\uffff"+
        "\1\60\1\165\2\60\1\56\3\uffff\1\56\11\uffff\2\164\1\124\1\144\1"+
        "\164\1\154\1\144\1\104\1\60\1\152\2\60\2\162\1\122\1\165\1\163\1"+
        "\151\1\144\1\146\1\160\1\60\1\165\1\125\1\160\1\120\1\146\1\106"+
        "\24\uffff\1\145\1\164\1\162\1\157\1\156\1\143\1\156\1\145\1\162"+
        "\1\143\1\160\1\165\1\141\1\144\1\157\1\155\1\141\1\104\1\144\1\uffff"+
        "\1\162\1\125\1\165\1\uffff\1\114\1\154\5\uffff\4\60\1\151\3\60\1"+
        "\145\1\uffff\1\145\3\60\1\141\1\145\1\163\2\60\1\154\1\60\1\146"+
        "\1\uffff\1\141\1\101\1\154\1\114\1\151\1\106\1\156\1\150\1\141\1"+
        "\145\1\141\1\143\1\164\2\163\1\144\1\60\1\164\2\145\1\154\1\162"+
        "\1\145\1\154\1\142\1\151\1\162\1\105\1\145\1\141\1\105\1\145\1\123"+
        "\1\163\2\uffff\1\157\1\uffff\1\162\1\143\1\uffff\1\154\1\60\1\164"+
        "\2\uffff\1\151\1\147\1\uffff\1\156\1\171\1\60\1\154\1\114\1\151"+
        "\1\111\1\156\1\116\1\131\3\60\1\154\1\156\2\164\1\60\1\145\1\141"+
        "\1\164\1\151\1\141\1\uffff\1\157\3\60\1\144\1\146\1\60\1\157\1\156"+
        "\1\164\1\106\1\146\1\164\2\60\1\105\1\145\1\156\1\145\1\164\1\163"+
        "\1\uffff\1\163\2\145\1\151\1\60\1\uffff\1\163\1\123\1\145\1\105"+
        "\1\151\1\111\1\60\2\uffff\1\154\1\164\1\60\1\151\1\uffff\1\60\1"+
        "\151\1\60\1\143\1\142\1\162\2\uffff\1\145\1\151\1\141\1\uffff\1"+
        "\154\1\147\1\60\1\111\2\151\3\60\1\144\3\60\1\163\1\162\1\164\2"+
        "\60\1\163\1\123\1\164\1\124\2\60\1\uffff\1\157\2\156\1\uffff\1\141"+
        "\1\154\1\60\1\162\2\156\2\60\1\uffff\1\116\1\156\1\157\1\uffff\1"+
        "\60\2\uffff\2\60\1\171\2\60\1\171\1\131\2\uffff\1\156\1\163\2\164"+
        "\1\145\1\uffff\2\145\1\60\2\uffff\1\105\1\145\1\156\2\uffff\6\60"+
        "\1\145\1\60\2\144\1\104\1\144\1\60\2\uffff\5\60\3\uffff";
    static final String DFA29_maxS =
        "\1\176\2\157\2\156\2\162\2\157\1\170\1\156\1\161\1\156\1\75\2\uffff"+
        "\1\75\1\uffff\1\57\3\uffff\2\75\1\165\1\151\1\165\1\157\1\162\1"+
        "\145\1\171\1\157\1\156\1\157\1\171\1\uffff\1\172\1\165\2\172\1\146"+
        "\3\uffff\1\56\11\uffff\2\164\1\124\1\144\1\164\1\154\1\144\1\104"+
        "\1\172\1\152\2\172\2\162\1\122\1\165\1\163\1\151\1\144\1\146\1\160"+
        "\1\172\1\165\1\125\1\160\1\120\1\146\1\106\24\uffff\1\145\1\164"+
        "\1\162\1\165\1\156\1\154\1\156\1\145\1\162\1\143\1\160\1\165\1\141"+
        "\2\157\1\155\1\162\1\104\1\144\1\uffff\1\162\1\125\1\165\1\uffff"+
        "\1\114\1\154\5\uffff\4\172\1\151\3\172\1\145\1\uffff\1\145\3\172"+
        "\1\141\1\145\1\163\2\172\1\154\1\172\1\164\1\uffff\1\141\1\101\1"+
        "\154\1\114\1\151\1\124\1\156\1\150\1\141\1\145\1\141\1\143\1\164"+
        "\1\163\1\164\1\144\1\172\1\164\2\145\1\154\1\162\1\145\1\154\1\142"+
        "\1\151\1\162\1\105\1\145\1\141\1\105\1\145\1\123\1\163\2\uffff\1"+
        "\157\1\uffff\1\162\1\143\1\uffff\1\154\1\172\1\164\2\uffff\1\151"+
        "\1\147\1\uffff\1\156\1\171\1\172\1\154\1\114\1\151\1\111\1\156\1"+
        "\116\1\131\3\172\1\154\1\156\2\164\1\172\1\145\1\141\1\164\1\151"+
        "\1\141\1\uffff\1\157\3\172\1\144\1\146\1\172\1\157\1\156\1\164\1"+
        "\106\1\146\1\164\2\172\1\105\1\145\1\156\1\145\1\164\1\163\1\uffff"+
        "\1\163\2\145\1\151\1\172\1\uffff\1\163\1\123\1\145\1\105\1\151\1"+
        "\111\1\172\2\uffff\1\154\1\164\1\172\1\151\1\uffff\1\172\1\151\1"+
        "\172\1\143\1\142\1\162\2\uffff\1\145\1\151\1\141\1\uffff\1\154\1"+
        "\147\1\172\1\111\2\151\3\172\1\144\3\172\1\163\1\162\1\164\2\172"+
        "\1\163\1\123\1\164\1\124\2\172\1\uffff\1\157\2\156\1\uffff\1\141"+
        "\1\154\1\172\1\162\2\156\2\172\1\uffff\1\116\1\156\1\157\1\uffff"+
        "\1\172\2\uffff\2\172\1\171\2\172\1\171\1\131\2\uffff\1\156\1\163"+
        "\2\164\1\145\1\uffff\2\145\1\172\2\uffff\1\105\1\145\1\156\2\uffff"+
        "\6\172\1\145\1\172\2\144\1\104\1\144\1\172\2\uffff\5\172\3\uffff";
    static final String DFA29_acceptS =
        "\16\uffff\1\10\1\11\1\uffff\1\13\1\uffff\1\15\1\16\1\17\15\uffff"+
        "\1\66\5\uffff\1\101\1\102\1\103\1\uffff\1\110\1\111\1\113\1\114"+
        "\1\115\1\116\1\117\1\120\1\122\34\uffff\1\12\1\20\1\7\1\104\1\105"+
        "\1\14\1\22\1\21\1\24\1\23\1\25\1\26\1\27\1\30\1\31\1\32\1\33\1\54"+
        "\1\121\1\112\23\uffff\1\67\3\uffff\1\75\2\uffff\1\76\1\77\1\100"+
        "\1\107\1\106\11\uffff\1\3\14\uffff\1\41\42\uffff\1\1\1\2\1\uffff"+
        "\1\70\2\uffff\1\4\3\uffff\1\72\1\5\2\uffff\1\60\27\uffff\1\47\25"+
        "\uffff\1\35\5\uffff\1\74\7\uffff\1\34\1\40\4\uffff\1\52\6\uffff"+
        "\1\50\1\53\3\uffff\1\57\30\uffff\1\61\3\uffff\1\43\10\uffff\1\71"+
        "\3\uffff\1\51\1\uffff\1\64\1\36\7\uffff\1\37\1\44\5\uffff\1\65\3"+
        "\uffff\1\62\1\63\3\uffff\1\55\1\6\15\uffff\1\45\1\42\5\uffff\1\73"+
        "\1\46\1\56";
    static final String DFA29_specialS =
        "\u0178\uffff}>";
    static final String[] DFA29_transitionS = {
            "\2\53\1\uffff\2\53\22\uffff\1\53\1\20\1\51\3\uffff\1\16\1\uffff"+
            "\1\57\1\60\1\21\1\23\1\55\1\24\1\54\1\22\12\50\1\30\1\56\1\26"+
            "\1\25\1\27\2\uffff\1\4\3\52\1\13\1\47\2\52\1\14\4\52\1\2\1\6"+
            "\4\52\1\46\1\44\2\52\1\10\2\52\1\63\1\uffff\1\64\1\43\1\65\1"+
            "\uffff\1\3\1\41\1\33\1\45\1\11\1\32\1\37\1\52\1\12\4\52\1\1"+
            "\1\5\1\34\2\52\1\42\1\36\1\40\1\35\1\31\1\7\2\52\1\61\1\17\1"+
            "\62\1\15",
            "\1\66",
            "\1\70\37\uffff\1\67",
            "\1\72\10\uffff\1\73\1\uffff\1\71",
            "\1\75\37\uffff\1\74",
            "\1\77\17\uffff\1\76",
            "\1\101\37\uffff\1\100",
            "\1\102",
            "\1\104\37\uffff\1\103",
            "\1\106\1\uffff\1\110\2\uffff\1\105\6\uffff\1\107",
            "\1\111\6\uffff\1\112\1\113",
            "\1\115\37\uffff\1\114",
            "\1\117\1\121\36\uffff\1\116\1\120",
            "\1\122\26\uffff\1\123",
            "",
            "",
            "\1\123",
            "",
            "\1\126\4\uffff\1\125",
            "",
            "",
            "",
            "\1\130",
            "\1\132",
            "\1\142\17\uffff\1\135\41\uffff\1\144\3\uffff\1\136\1\143\4"+
            "\uffff\1\134\2\uffff\1\141\3\uffff\1\137\4\uffff\1\140",
            "\1\146\1\147",
            "\1\153\12\uffff\1\151\2\uffff\1\150\5\uffff\1\152",
            "\1\154",
            "\1\155",
            "\1\156\3\uffff\1\157",
            "\1\161\6\uffff\1\160",
            "\1\162",
            "\1\163",
            "\1\164",
            "\1\166\4\uffff\1\165",
            "",
            "\12\52\7\uffff\15\52\1\167\14\52\4\uffff\1\52\1\uffff\15\52"+
            "\1\170\14\52",
            "\1\172",
            "\12\52\7\uffff\21\52\1\173\10\52\4\uffff\1\52\1\uffff\21\52"+
            "\1\174\10\52",
            "\12\52\7\uffff\1\176\31\52\4\uffff\1\52\1\uffff\1\177\31\52",
            "\1\u0082\1\uffff\12\50\54\uffff\1\u0082",
            "",
            "",
            "",
            "\1\u0083",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\u0085",
            "\1\u0086",
            "\1\u0087",
            "\1\u0088",
            "\1\u0089",
            "\1\u008a",
            "\1\u008b",
            "\1\u008c",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\3\52\1\u008d\26\52",
            "\1\u008f",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\1\u0090",
            "\1\u0091",
            "\1\u0092",
            "\1\u0093",
            "\1\u0094",
            "\1\u0095",
            "\1\u0096",
            "\1\u0097",
            "\1\u0098",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\5\52\1\u009a\15\52"+
            "\1\u0099\6\52",
            "\1\u009c",
            "\1\u009d",
            "\1\u009e",
            "\1\u009f",
            "\1\u00a0",
            "\1\u00a1",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\u00a2",
            "\1\u00a3",
            "\1\u00a4",
            "\1\u00a6\5\uffff\1\u00a5",
            "\1\u00a7",
            "\1\u00a8\10\uffff\1\u00a9",
            "\1\u00aa",
            "\1\u00ab",
            "\1\u00ac",
            "\1\u00ad",
            "\1\u00ae",
            "\1\u00af",
            "\1\u00b0",
            "\1\u00b2\12\uffff\1\u00b1",
            "\1\u00b3",
            "\1\u00b4",
            "\1\u00b6\20\uffff\1\u00b5",
            "\1\u00b7",
            "\1\u00b8",
            "",
            "\1\u00b9",
            "\1\u00ba",
            "\1\u00bb",
            "",
            "\1\u00bc",
            "\1\u00bd",
            "",
            "",
            "",
            "",
            "",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\1\u00c0",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\1\u00c2",
            "",
            "\1\u00c3",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\1\u00c5",
            "\1\u00c6",
            "\1\u00c7",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\1\u00ca",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\4\52\1\u00cb\25\52",
            "\1\u00cf\2\uffff\1\u00cd\12\uffff\1\u00ce",
            "",
            "\1\u00d0",
            "\1\u00d1",
            "\1\u00d2",
            "\1\u00d3",
            "\1\u00d4",
            "\1\u00d7\2\uffff\1\u00d5\12\uffff\1\u00d6",
            "\1\u00d8",
            "\1\u00d9",
            "\1\u00da",
            "\1\u00db",
            "\1\u00dc",
            "\1\u00dd",
            "\1\u00de",
            "\1\u00df",
            "\1\u00e1\1\u00e0",
            "\1\u00e2",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\10\52\1\u00e3\21"+
            "\52",
            "\1\u00e5",
            "\1\u00e6",
            "\1\u00e7",
            "\1\u00e8",
            "\1\u00e9",
            "\1\u00ea",
            "\1\u00eb",
            "\1\u00ec",
            "\1\u00ed",
            "\1\u00ee",
            "\1\u00ef",
            "\1\u00f0",
            "\1\u00f1",
            "\1\u00f2",
            "\1\u00f3",
            "\1\u00f4",
            "\1\u00f5",
            "",
            "",
            "\1\u00f6",
            "",
            "\1\u00f7",
            "\1\u00f8",
            "",
            "\1\u00f9",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\1\u00fb",
            "",
            "",
            "\1\u00fc",
            "\1\u00fd",
            "",
            "\1\u00fe",
            "\1\u00ff",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\1\u0101",
            "\1\u0102",
            "\1\u0103",
            "\1\u0104",
            "\1\u0105",
            "\1\u0106",
            "\1\u0107",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\1\u010a",
            "\1\u010b",
            "\1\u010c",
            "\1\u010d",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\1\u010f",
            "\1\u0110",
            "\1\u0111",
            "\1\u0112",
            "\1\u0113",
            "",
            "\1\u0114",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\1\u0117",
            "\1\u0118",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\4\52\1\u0119\25\52",
            "\1\u011b",
            "\1\u011c",
            "\1\u011d",
            "\1\u011e",
            "\1\u011f",
            "\1\u0120",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\1\u0121",
            "\1\u0122",
            "\1\u0123",
            "\1\u0124",
            "\1\u0125",
            "\1\u0126",
            "",
            "\1\u0127",
            "\1\u0128",
            "\1\u0129",
            "\1\u012a",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "",
            "\1\u012b",
            "\1\u012c",
            "\1\u012d",
            "\1\u012e",
            "\1\u012f",
            "\1\u0130",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "",
            "",
            "\1\u0131",
            "\1\u0132",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\1\u0134",
            "",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\1\u0135",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\1\u0136\31\52",
            "\1\u0138",
            "\1\u0139",
            "\1\u013a",
            "",
            "",
            "\1\u013b",
            "\1\u013c",
            "\1\u013d",
            "",
            "\1\u013e",
            "\1\u013f",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\1\u0141",
            "\1\u0142",
            "\1\u0143",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\1\u0145",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\1\u0148",
            "\1\u0149",
            "\1\u014a",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\1\u014b",
            "\1\u014c",
            "\1\u014d",
            "\1\u014e",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "",
            "\1\u0151",
            "\1\u0152",
            "\1\u0153",
            "",
            "\1\u0154",
            "\1\u0155",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\1\u0157",
            "\1\u0158",
            "\1\u0159",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "",
            "\1\u015c",
            "\1\u015d",
            "\1\u015e",
            "",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "",
            "",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\1\u0161",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\1\u0162",
            "\1\u0163",
            "",
            "",
            "\1\u0164",
            "\1\u0165",
            "\1\u0166",
            "\1\u0167",
            "\1\u0168",
            "",
            "\1\u0169",
            "\1\u016a",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "",
            "",
            "\1\u016b",
            "\1\u016c",
            "\1\u016d",
            "",
            "",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\1\u0170",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\1\u0171",
            "\1\u0172",
            "\1\u0173",
            "\1\u0174",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "",
            "",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "\12\52\7\uffff\32\52\4\uffff\1\52\1\uffff\32\52",
            "",
            "",
            ""
    };

    static final short[] DFA29_eot = DFA.unpackEncodedString(DFA29_eotS);
    static final short[] DFA29_eof = DFA.unpackEncodedString(DFA29_eofS);
    static final char[] DFA29_min = DFA.unpackEncodedStringToUnsignedChars(DFA29_minS);
    static final char[] DFA29_max = DFA.unpackEncodedStringToUnsignedChars(DFA29_maxS);
    static final short[] DFA29_accept = DFA.unpackEncodedString(DFA29_acceptS);
    static final short[] DFA29_special = DFA.unpackEncodedString(DFA29_specialS);
    static final short[][] DFA29_transition;

    static {
        int numStates = DFA29_transitionS.length;
        DFA29_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA29_transition[i] = DFA.unpackEncodedString(DFA29_transitionS[i]);
        }
    }

    class DFA29 extends DFA {

        public DFA29(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 29;
            this.eot = DFA29_eot;
            this.eof = DFA29_eof;
            this.min = DFA29_min;
            this.max = DFA29_max;
            this.accept = DFA29_accept;
            this.special = DFA29_special;
            this.transition = DFA29_transition;
        }
        public String getDescription() {
            return "1:1: Tokens : ( NotLog | AndLog | OrLog | XorLog | EqualLog | Implies | NotBit | AndBit | OrBit | XorBit | Times | Divide | Plus | Minus | Equal | NotEqual | LessThan | LessThanE | GreaterThan | GreaterThanE | SetAssign | Assign | Consume | Produce | Use | Lend | Change | When | Else | Exists | ForAll | With | Within | Contains | Constant | Fluent | Function | Predicate | Variable | Type | Action | Fact | Goal | Decomposition | Ordered | Unordered | Boolean | Integer | Float | Symbol | String | Object | Vector | Delta | Undefined | All | Start | End | Duration | Infinity | True | False | INT | FLOAT | STRING | ID | WS | SLC | MLC | Dot | Dots | Comma | Semi | Colon | LeftP | RightP | LeftC | RightC | LeftB | RightB | Undefine | Skip );";
        }
    }
 

}